#!/bin/sh
#
# The docker HA resource agent creates and launches a docker container
# based off a supplied docker image. Containers managed by this agent
# are both created and removed upon the agent's start and stop actions.
#
# Copyright (c) 2014 David Vossel <davidvossel@gmail.com>
#                    All Rights Reserved.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of version 2 of the GNU General Public License as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it would be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#
# Further, this software is distributed without any warranty that it is
# free of the rightful claim of any third person regarding infringement
# or the like.  Any license provided herein, whether implied or
# otherwise, applies only to this software file.  Patent licenses, if
# any, provided herein do not apply to combinations of this program with
# other software, or any other product whatsoever.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write the Free Software Foundation,
# Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
#

#######################################################################
# Initialization:

: ${OCF_FUNCTIONS_DIR=${OCF_ROOT}/lib/heartbeat}
. ${OCF_FUNCTIONS_DIR}/ocf-shellfuncs

#######################################################################

COMPOSE=/usr/local/bin/docker-compose

meta_data()
{
    cat <<END
<?xml version="1.0"?>
<!DOCTYPE resource-agent SYSTEM "ra-api-1.dtd">
<resource-agent name="compose">
<version>1.0</version>

<longdesc lang="en">
The docker HA resource agent creates and launches a docker container
based off a supplied docker image. Containers managed by this agent
are both created and removed upon the agent's start and stop actions.
</longdesc>
<shortdesc lang="en">Docker container resource agent.</shortdesc>

<parameters>
<parameter name="conf" required="1" unique="0">
<longdesc lang="en">
The docker compose config path.
</longdesc>
<shortdesc lang="en">docker compose config</shortdesc>
<content type="string"/>
</parameter>

<parameter name="env_path" required="0" unique="0">
<longdesc lang="en">
The docker compose environment file path.
</longdesc>
<shortdesc lang="en">docker compose environment</shortdesc>
<content type="string"/>
</parameter>

<parameter name="image" required="0" unique="0">
<longdesc lang="en">
The docker image to base this container off of.
</longdesc>
<shortdesc lang="en">docker image</shortdesc>
<content type="string"/>
</parameter>

<parameter name="name" required="0" unique="0">
<longdesc lang="en">
The name to give the created container. By default this will
be that resource's instance name.
</longdesc>
<shortdesc lang="en">docker container name</shortdesc>
<content type="string"/>
</parameter>

<parameter name="allow_pull" unique="0">
<longdesc lang="en">
Allow the image to be pulled from the configured docker registry when
the image does not exist locally. NOTE, this can drastically increase
the time required to start the container if the image repository is
pulled over the network.
</longdesc>
<shortdesc lang="en">Allow pulling non-local images</shortdesc>
<content type="boolean"/>
</parameter>

<parameter name="run_opts" required="0" unique="0">
<longdesc lang="en">
Add options to be appended to the 'docker run' command which is used
when creating the container during the start action. This option allows
users to do things such as setting a custom entry point and injecting
environment variables into the newly created container. Note the '-d'
option is supplied regardless of this value to force containers to run
in the background.

NOTE: Do not explicitly specify the --name argument in the run_opts. This
agent will set --name using either the resource's instance or the name
provided in the 'name' argument of this agent.

</longdesc>
<shortdesc lang="en">run options</shortdesc>
<content type="string"/>
</parameter>

<parameter name="run_cmd" required="0" unique="0">
<longdesc lang="en">
Specifiy a command to launch within the container once
it has initialized.
</longdesc>
<shortdesc lang="en">run command</shortdesc>
<content type="string"/>
</parameter>

<parameter name="mount_points" required="0" unique="0">
<longdesc lang="en">
A comma separated list of directories that the container is expecting to use.
The agent will ensure they exist by running 'mkdir -p' 
</longdesc>
<shortdesc lang="en">Required mount points</shortdesc>
<content type="string"/>
</parameter>

<parameter name="monitor_cmd" required="0" unique="0">
<longdesc lang="en">
Specifiy the full path of a command to launch within the container to check
the health of the container. This command must return 0 to indicate that
the container is healthy. A non-zero return code will indicate that the
container has failed and should be recovered.

If 'docker exec' is supported, it is used to execute the command. If not,
nsenter is used.

Note: Using this method for monitoring processes inside a container
is not recommended, as containerd tries to track processes running
inside the container and does not deal well with many short-lived
processes being spawned. Ensure that your container monitors its
own processes and terminates on fatal error rather than invoking
a command from the outside.
</longdesc>
<shortdesc lang="en">monitor command</shortdesc>
<content type="string"/>
</parameter>

<parameter name="force_kill" required="0" unique="0">
<longdesc lang="en">
Kill a container immediately rather than waiting for it to gracefully
shutdown
</longdesc>
<shortdesc lang="en">force kill</shortdesc>
<content type="boolean"/>
</parameter>

<parameter name="reuse" required="0" unique="0">
<longdesc lang="en">
Allow the container to be reused after stopping the container. By default
containers are removed after stop. With the reuse option containers
will persist after the container stops.
</longdesc>
<shortdesc lang="en">reuse container</shortdesc>
<content type="boolean"/>
</parameter>

<parameter name="query_docker_health" required="0" unique="0">
<longdesc lang="en">
Query the builtin healthcheck of docker (v1.12+) to determine health of the
container. If left empty or set to false it will not be used.

The healthcheck itself has to be configured within docker, e.g. via
HEALTHCHECK in Dockerfile. This option just queries in what condition
docker considers the container to be and lets ocf do its thing accordingly.

Note that the time a container is in "starting" state counts against the
monitor timeout.

This is an additional check besides the standard check for the container
to be running, and the optional monitor_cmd check. It doesn't disable or
override them, so all of them (if used) have to come back healthy for the
container to be considered healthy.
</longdesc>
<shortdesc lang="en">use healthcheck</shortdesc>
<content type="boolean"/>
</parameter>

</parameters>

<actions>
<action name="start"        timeout="90s" />
<action name="stop"         timeout="90s" />
<action name="monitor"      timeout="30s" interval="30s" depth="0" />
<action name="meta-data"    timeout="5s" />
<action name="validate-all"   timeout="30s" />
</actions>
</resource-agent>
END
}

#######################################################################
REQUIRE_IMAGE_PULL=0

docker_usage()
{
    cat <<END
usage: $0 {start|stop|monitor|validate-all|meta-data}

Expects to have a fully populated OCF RA-compliant environment set.
END
}


monitor_cmd_exec()
{
    local rc=$OCF_SUCCESS
    local out

    if [ -z "$OCF_RESKEY_monitor_cmd" ]; then
        return $rc
    fi

    if docker exec --help >/dev/null 2>&1; then
        out=$(docker exec ${CONTAINER} $OCF_RESKEY_monitor_cmd 2>&1)
        rc=$?
    else
        out=$(echo "$OCF_RESKEY_monitor_cmd" | nsenter --target $(docker inspect --format {{.State.Pid}} ${CONTAINER}) --mount --uts --ipc --net --pid 2>&1)
        rc=$?
    fi

    if [ $rc -eq 127 ]; then
        ocf_log err "monitor cmd failed (rc=$rc), output: $out"
        ocf_exit_reason "monitor_cmd, ${OCF_RESKEY_monitor_cmd} , not found within container."
        # there is no recovering from this, exit immediately
        exit $OCF_ERR_ARGS
    elif [ $rc -ne 0 ]; then
        ocf_exit_reason "monitor cmd failed (rc=$rc), output: $out"
        rc=$OCF_ERR_GENERIC
    else
        ocf_log debug "monitor cmd passed: exit code = $rc"
    fi

    return $rc
}

container_exists()
{
    docker inspect --format {{.State.Running}} $CONTAINER | egrep '(true|false)' >/dev/null 2>&1
}

remove_container()
{
    if ocf_is_true "$OCF_RESKEY_reuse"; then
        # never remove the container if we have reuse enabled.
        return 0
    fi

    container_exists
    if [ $? -ne 0 ]; then
        # don't attempt to remove a container that doesn't exist
        return 0
    fi
    ocf_log notice "Cleaning up inactive container, ${CONTAINER}."
    ocf_run docker rm $CONTAINER
}

docker_simple_status()
{
    local val

    container_exists
    if [ $? -ne 0 ]; then
        return $OCF_NOT_RUNNING
    fi

    # retrieve the 'Running' attribute for the container
    val=$(docker inspect --format {{.State.Running}} $CONTAINER 2>/dev/null)
    if [ $? -ne 0 ]; then
        #not running as a result of container not being found
        return $OCF_NOT_RUNNING
    fi

    if ocf_is_true "$val"; then
        # container exists and is running
        return $OCF_SUCCESS
    fi

    return $OCF_NOT_RUNNING
}

docker_health_status()
{

    if ocf_is_true "$OCF_RESKEY_query_docker_health"; then
                local val

                container_exists
                if [ $? -ne 0 ]; then
                        return $OCF_NOT_RUNNING
                fi

                # retrieve the 'Health' attribute for the container
                # This is a bash-style do-while loop to wait until instance is started.
                # if starting takes longer than monitor timeout then upstream will make this fail.
                while

                        val=$(docker inspect --format {{.State.Health.Status}} $CONTAINER 2>/dev/null)
                        if [ $? -ne 0 ]; then
                                #not healthy as a result of container not being found
                                return $OCF_NOT_RUNNING
                        fi
                        test "$val" = "starting"
                do

                        sleep 1
                done

                if [ "$val" = "healthy" ]; then
                        # container exists and is healthy
                        return $OCF_SUCCESS
                fi

                return $OCF_NOT_RUNNING
    fi

    return 0
}



docker_monitor()
{
    local rc=0

    ocf_log info "docker-compose monitor start"

    $COMPOSE -f ${OCF_RESKEY_conf} config

    rc=$?
    if [ $rc -ne 0 ]; then
        return $OCF_NOT_RUNNING
    fi

    $COMPOSE -f ${OCF_RESKEY_conf} ps |grep 'Exit'
    rc=$?
    if [ $rc -eq 0 ]; then
        return $OCF_NOT_RUNNING
    fi
    
    rc=$($COMPOSE -f ${OCF_RESKEY_conf} ps -q |wc -l)
    if [ $rc -eq 0 ]; then
        ocf_log info "docker-compose monitor not running $rc"
        return $OCF_NOT_RUNNING
    fi
}

docker_create_mounts() {
    oldIFS="$IFS"
    IFS=","
    for directory in $OCF_RESKEY_mount_points; do
        mkdir -p "$directory"
    done
    IFS="$oldIFS"
}

evaluate_env() {
    echo "# Custom environment from /opt/isard/config/$(hostname)/<ENV_VAR>" > /tmp/pcs_compose_env
    echo "# Called on compose ${OCF_RESKEY_conf}" >> /tmp/pcs_compose_env
    echo "# $(date)" >> /tmp/pcs_compose_env
    echo "############ BEGIN ############" >> /tmp/pcs_compose_env
    export HYPER_ID=$(hostname)

    for ev in DOMAIN HYPER_ID VIDEO_DOMAIN VIEWER_SPICE VIEWER_BROWSER STORAGE_DOMAIN
    do
        path=/opt/isard/config/$(hostname)/
        if [ -f $path$ev ]; then
            export ${ev}=$(cat $path$ev)
            echo "export ${ev}=$(cat $path$ev)" >> /tmp/pcs_compose_env
        fi
    done
    echo "############ END ##############" >> /tmp/pcs_compose_env
    echo "# NOTE: Variables set in ${OCF_RESKEY_conf} will override this ones." >> /tmp/pcs_compose_env
    echo "#       Variables not set in ${OCF_RESKEY_conf} will apply this ones." >> /tmp/pcs_compose_env
    echo "#       If variable missing in both, defaults will be applied." >> /tmp/pcs_compose_env
}

docker_start()
{
    ocf_log info "docker-compose start"
    docker_create_mounts

    if [ -n "$OCF_RESKEY_run_opts" ]; then
        run_opts=$OCF_RESKEY_run_opts
    fi

    evaluate_env
    ocf_run $COMPOSE -f ${OCF_RESKEY_conf} up -d ${run_opts}

    sleep 5
    if [ $? -ne 0 ]; then
        ocf_exit_reason "docker-compose failed to launch container"
        return $OCF_ERR_GENERIC
    fi
}

docker_stop()
{
    ocf_log info "docker-compose stop"
    local timeout=60

    if [ ! -f "$OCF_RESKEY_conf" ]; then
        ocf_exit_reason "'conf' option is required"
        exit $OCF_SUCCESS
    fi

    $COMPOSE -f ${OCF_RESKEY_conf} ps |grep 'Exit'
    rc=$?
    if [ $rc -eq 0 ]; then
        ocf_run $COMPOSE -f ${OCF_RESKEY_conf} down
        return $OCF_SUCCESS
    fi
    
        $COMPOSE -f ${OCF_RESKEY_conf} ps |awk '{if(NR>2)print}' |wc -l
    rc=$?
    if [ $rc -ne 0 ]; then
        return $OCF_NOT_RUNNING
    fi

    if ocf_is_true "$OCF_RESKEY_force_kill"; then
        ocf_run $COMPOSE -f ${OCF_RESKEY_conf} kill
    else
        ocf_log debug "waiting $timeout second[s] before killing container"
        ocf_run $COMPOSE -f ${OCF_RESKEY_conf} stop
    fi

    if [ $? -ne 0 ]; then
        ocf_exit_reason "Docker-compose failed to stop container."
        return $OCF_ERR_GENERIC
    fi

    ocf_run $COMPOSE -f ${OCF_RESKEY_conf} rm -f    
    if [ $? -ne 0 ]; then
        ocf_exit_reason "Docker-compose failed to remove stopped container."
        return $OCF_ERR_GENERIC
    fi

    return $OCF_SUCCESS
}

image_exists()
{
    # if no tag was specified, use default "latest"
    local COLON_FOUND=0
    local SLASH_FOUND=0
    local SERVER_NAME=""
    local IMAGE_NAME="${OCF_RESKEY_image}"
    local IMAGE_TAG="latest"

    SLASH_FOUND="$(echo "${OCF_RESKEY_image}" | grep -o '/' | grep -c .)"

    if [ ${SLASH_FOUND} -ge 1 ]; then
        SERVER_NAME="$(echo ${IMAGE_NAME} | cut -d / -f 1-${SLASH_FOUND})"
        IMAGE_NAME="$(echo ${IMAGE_NAME} | awk -F'/' '{print $NF}')"
    fi

    COLON_FOUND="$(echo "${IMAGE_NAME}" | grep -o ':' | grep -c .)"
    if [ ${COLON_FOUND} -ge 1 ]; then
        IMAGE_TAG="$(echo ${IMAGE_NAME} | awk -F':' '{print $NF}')"
        IMAGE_NAME="$(echo ${IMAGE_NAME} | cut -d : -f 1-${COLON_FOUND})"
    fi

    # IMAGE_NAME might be following formats:
    # - image
    # - repository:port/image
    # - docker.io/image (some distro will display "docker.io/" as prefix)
    docker images | awk '{print $1 ":" $2}' | egrep -q -s "^(docker.io\/|${SERVER_NAME}\/)?${IMAGE_NAME}:${IMAGE_TAG}\$"
    if [ $? -eq 0 ]; then
        # image found
        return 0
    fi

    if ocf_is_true "$OCF_RESKEY_allow_pull"; then
        REQUIRE_IMAGE_PULL=1
        ocf_log notice "Image (${OCF_RESKEY_image}) does not exist locally but will be pulled during start"
        return 0
    fi
    # image not found.
    return 1
}

docker_validate()
{
    check_binary docker
    ocf_log info "docker validate"

    if [ -z "$OCF_RESKEY_conf" ]; then
        ocf_exit_reason "'conf' option is required"
        exit $OCF_ERR_CONFIGURED
    fi

    ocf_log info "docker validate1"
    if [ -n "$OCF_RESKEY_monitor_cmd" ]; then
        docker exec --help >/dev/null 2>&1
        if [ ! $? ]; then
            ocf_log info "checking for nsenter, which is required when 'monitor_cmd' is specified"
            check_binary nsenter
        fi
    fi
    ocf_log info "docker validate2"

    return $OCF_SUCCESS
}

# TODO :
# When a user starts plural clones in a node in globally-unique, a user cannot appoint plural name parameters.
# When a user appoints reuse, the resource agent cannot connect plural clones with a container.

if ocf_is_true "$OCF_RESKEY_CRM_meta_globally_unique"; then
    if [ -n "$OCF_RESKEY_name" ]; then
        if [ -n "$OCF_RESKEY_CRM_meta_clone_node_max" ] && [ "$OCF_RESKEY_CRM_meta_clone_node_max" -ne 1 ]
        then
            ocf_exit_reason "Cannot make plural clones from the same name parameter."
            exit $OCF_ERR_CONFIGURED
        fi
        if [ -n "$OCF_RESKEY_CRM_meta_master_node_max" ] && [ "$OCF_RESKEY_CRM_meta_master_node_max" -ne 1 ]
        then
            ocf_exit_reason "Cannot make plural master from the same name parameter."
            exit $OCF_ERR_CONFIGURED
        fi
    fi
    : ${OCF_RESKEY_name=`echo ${OCF_RESOURCE_INSTANCE} | tr ':' '-'`} 
else 
    : ${OCF_RESKEY_name=${OCF_RESOURCE_INSTANCE}}
fi

if [ -n "$OCF_RESKEY_container" ]; then
    # we'll keep the container attribute around for a bit in order not to break
    # any existing deployments. The 'name' attribute is prefered now though.
    CONTAINER=$OCF_RESKEY_container
    ocf_log warn "The 'container' attribute is depreciated"
else
    CONTAINER=$OCF_RESKEY_name
fi

if [ -n "$OCF_RESKEY_env_path" ]; then
    cd ${OCF_RESKEY_env_path}
fi

case $__OCF_ACTION in
meta-data) meta_data
        exit $OCF_SUCCESS;;
start)
    docker_validate
    docker_start;;
stop)       docker_stop;;
monitor)    docker_monitor;;
validate-all)   docker_validate;;
usage|help) docker_usage
        exit $OCF_SUCCESS
        ;;
*)      docker_usage
        exit $OCF_ERR_UNIMPLEMENTED
        ;;
esac
rc=$?
ocf_log debug "${OCF_RESOURCE_INSTANCE} $__OCF_ACTION : $rc"
exit $rc

